{{#withSeparateModelsAndApi}}
/* tslint:disable */
/* eslint-disable */
{{>licenseInfo}}

import globalAxios, { AxiosPromise, AxiosInstance, AxiosRequestConfig } from 'axios';
import { Configuration } from '{{apiRelativeToRoot}}configuration';
{{#withNodeImports}}
// URLSearchParams not necessarily used
// @ts-ignore
import { URL, URLSearchParams } from 'url';
{{#multipartFormData}}
import FormData from 'form-data'
{{/multipartFormData}}
{{/withNodeImports}}
// Some imports not used depending on template conditions
// @ts-ignore
import { DUMMY_BASE_URL, assertParamExists, setApiKeyToObject, setBasicAuthToObject, setBearerAuthToObject, setSearchParams, serializeDataIfNeeded, toPathString, createRequestFunction, isBrowser } from '{{apiRelativeToRoot}}common';
{{#infoExtensions.x-konfig-uses-multipart-form-data}}
import { fromBuffer } from "file-type/browser"
const FormData = require("form-data")
{{/infoExtensions.x-konfig-uses-multipart-form-data}}
{{#hasOAuthMethods}}
import { setOAuthToObject } from '{{apiRelativeToRoot}}common';
{{/hasOAuthMethods}}
// @ts-ignore
import { BASE_PATH, COLLECTION_FORMATS, RequestArgs, BaseAPI, RequiredError } from '{{apiRelativeToRoot}}base';
{{#imports}}
// @ts-ignore
import { {{classname}} } from '{{apiRelativeToRoot}}{{tsModelPackage}}';
{{/imports}}
import { paginate } from "../pagination/paginate";
import type * as buffer from "buffer"
import { requestBeforeHook } from '../requestBeforeHook';
{{/withSeparateModelsAndApi}}
{{^withSeparateModelsAndApi}}
{{/withSeparateModelsAndApi}}
{{#operations}}
/**
 * {{classname}} - axios parameter creator{{#description}}
 * {{&description}}{{/description}}
 * @export
 */
export const {{classname}}AxiosParamCreator = function (configuration?: Configuration) {
    return {
    {{#operation}}
        /**
         * {{&notes}}
         {{#summary}}
         * @summary {{&summary}}
         {{/summary}}
         {{#allParams}}
         * @param {{=<% %>=}}{<%&dataType%>}<%={{ }}=%> {{^required}}[{{/required}}{{> requestPropertyName}}{{^required}}]{{/required}} {{description}}
         {{/allParams}}
         * @param {*} [options] Override http request option.{{#isDeprecated}}
         * @deprecated{{/isDeprecated}}
         * @throws {RequiredError}
         */
        {{nickname}}: async ({{#allParams}}{{> requestPropertyName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
    {{#allParams}}
    {{#required}}
            // verify required parameter '{{> requestPropertyName}}' is not null or undefined
            assertParamExists('{{nickname}}', '{{> requestPropertyName}}', {{> requestPropertyName}})
    {{/required}}
    {{/allParams}}
            const localVarPath = `{{{path}}}`{{#pathParams}}
                .replace(`{${"{{baseName}}"}}`, encodeURIComponent(String({{>requestPropertyName}} !== undefined ? {{> requestPropertyName}} : `-{{{baseName}}}-`))){{/pathParams}};
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions: AxiosRequestConfig = { method: '{{httpMethod}}', ...baseOptions, ...options};
            const localVarHeaderParameter = configuration && !isBrowser() ? { "User-Agent": configuration.userAgent } : {} as any;
            const localVarQueryParameter = {} as any;
            {{#vendorExtensions}}
            {{#multipartFormData}}
            const localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
            const addFormParam = async (name: string, data: any, isBinary: boolean, isPrimitiveType: boolean) => {
                if (isBinary) {
                    if (data instanceof Uint8Array) {
                        // Handle Buffer data
                        const filetype = await fromBuffer(data)
                        const filename = filetype === undefined ? name : `${name}.${filetype.ext}`
                        localVarFormParams.append(name, data as any, filename);
                    } else if ("name" in data) {
                        // File instances in browsers and Node.js have the
                        // "name" property "Duck typing" files to handle browser
                        // File class or Node.js File class
                        // Web: https://developer.mozilla.org/en-US/docs/Web/API/File
                        // Node.js: https://nodejs.org/api/buffer.html#new-bufferfilesources-filename-options
                        if (isBrowser()) {
                            // FormData in browser can accept File/Blob directly
                            localVarFormParams.append(name, data, data.name);
                        } else {
                            // FormData in Node.js can only accept raw Buffer so convert before passing
                            const bytes = await data.arrayBuffer()
                            const buffer = Buffer.from(bytes)
                            localVarFormParams.append(name, buffer, data.name);
                        }
                    }
                } else {
                    if (isPrimitiveType) {
                        /**
                         * FormData can only accept string or Blob so we need to convert
                         * non-string primitives to string. We also need to convert
                         */
                        if (typeof data === "object") {
                          localVarFormParams.append(name, JSON.stringify(data));
                        } else {
                          localVarFormParams.append(name, data);
                        }
                    } else {
                        if (isBrowser()) {
                            localVarFormParams.append(name, new Blob([JSON.stringify(data)], { type: "application/json" }))
                        } else {
                            localVarFormParams.append(name, JSON.stringify(data), { type: "application/json", filename: "data.json" });
                        }
                    }
                }
            }
            if (!isBrowser()) Object.assign(localVarHeaderParameter, localVarFormParams.getHeaders());
            {{/multipartFormData}}
            {{/vendorExtensions}}

    {{#authMethods}}
            // authentication {{name}} required
            {{#isApiKey}}
            {{#isKeyInHeader}}
            await setApiKeyToObject({ object: localVarHeaderParameter, key: "{{keyParamName}}", keyParamName: "{{> securityKeyName}}", configuration{{#vendorExtensions.x-konfig-prefix}}, prefix: "{{vendorExtensions.x-konfig-prefix}}"{{/vendorExtensions.x-konfig-prefix}} })
            {{/isKeyInHeader}}
            {{#isKeyInQuery}}
            await setApiKeyToObject({object: localVarQueryParameter, key: "{{keyParamName}}", keyParamName: "{{> securityKeyName}}", configuration})
            {{/isKeyInQuery}}
            {{#isKeyInCookie}}
            await setApiKeyToObject({object: localVarHeaderParameter, type: "Cookie", key: "Cookie", keyParamName: "{{keyParamName}}", configuration})
            {{/isKeyInCookie}}
            {{/isApiKey}}
            {{#isBasicBasic}}
            // http basic authentication required
            setBasicAuthToObject(localVarRequestOptions, configuration)
            {{/isBasicBasic}}
            {{#isBasicBearer}}
            // http bearer authentication required
            await setBearerAuthToObject(localVarHeaderParameter, configuration)
            {{/isBasicBearer}}
            {{#isOAuth}}
            // oauth required
            await setOAuthToObject(localVarHeaderParameter, "{{name}}", [{{#scopes}}"{{{scope}}}"{{^-last}}, {{/-last}}{{/scopes}}], configuration)
            {{/isOAuth}}
    {{/authMethods}}
    {{#queryParams}}
            {{#isArray}}
            if ({{> requestPropertyName}}) {
            {{#isCollectionFormatMulti}}
                {{#uniqueItems}}
                localVarQueryParameter['{{baseName}}'] = Array.from({{> requestPropertyName}});
                {{/uniqueItems}}
                {{^uniqueItems}}
                localVarQueryParameter['{{baseName}}'] = {{> requestPropertyName}};
                {{/uniqueItems}}
            {{/isCollectionFormatMulti}}
            {{^isCollectionFormatMulti}}
                {{#uniqueItems}}
                localVarQueryParameter['{{baseName}}'] = Array.from({{> requestPropertyName}}).join(COLLECTION_FORMATS.{{collectionFormat}});
                {{/uniqueItems}}
                {{^uniqueItems}}
                localVarQueryParameter['{{baseName}}'] = {{> requestPropertyName}}.join(COLLECTION_FORMATS.{{collectionFormat}});
                {{/uniqueItems}}
            {{/isCollectionFormatMulti}}
            }
            {{/isArray}}
            {{^isArray}}
            if ({{> requestPropertyName}} !== undefined) {
                {{#isDateTime}}
                localVarQueryParameter['{{baseName}}'] = ({{> requestPropertyName}} as any instanceof Date) ?
                    ({{> requestPropertyName}} as any).toISOString() :
                    {{> requestPropertyName}};
                {{/isDateTime}}
                {{^isDateTime}}
                {{#isDate}}
                localVarQueryParameter['{{baseName}}'] = ({{> requestPropertyName}} as any instanceof Date) ?
                    ({{> requestPropertyName}} as any).toISOString().substr(0,10) :
                    {{> requestPropertyName}};
                {{/isDate}}
                {{^isDate}}
                localVarQueryParameter['{{baseName}}'] = {{> requestPropertyName}};
                {{/isDate}}
                {{/isDateTime}}
            }
            {{/isArray}}

    {{/queryParams}}
    {{#headerParams}}
            {{#isArray}}
            if ({{> requestPropertyName}}) {
                {{#uniqueItems}}
                let mapped = Array.from({{> requestPropertyName}}).map(value => (<any>"{{{dataType}}}" !== "Set<string>") ? JSON.stringify(value) : (value || ""));
                {{/uniqueItems}}
                {{^uniqueItems}}
                let mapped = {{> requestPropertyName}}.map(value => (<any>"{{{dataType}}}" !== "Array<string>") ? JSON.stringify(value) : (value || ""));
                {{/uniqueItems}}
                localVarHeaderParameter['{{baseName}}'] = mapped.join(COLLECTION_FORMATS["{{collectionFormat}}"]);
            }
            {{/isArray}}
            {{^isArray}}
            {{! `val == null` covers for both `null` and `undefined`}}
            if ({{> requestPropertyName}} != null) {
                {{#isString}}
                localVarHeaderParameter['{{baseName}}'] = String({{> requestPropertyName}});
                {{/isString}}
                {{^isString}}
                {{! isString is falsy also for $ref that defines a string or enum type}}
                localVarHeaderParameter['{{baseName}}'] = typeof {{> requestPropertyName}} === 'string'
                    ? {{> requestPropertyName}}
                    : JSON.stringify({{> requestPropertyName}});
                {{/isString}}
            }
            {{/isArray}}

    {{/headerParams}}
    {{#vendorExtensions}}
    {{#formParams}}
            {{#isArray}}
        if ({{> requestPropertyName}}) {
            {{#isCollectionFormatMulti}}
                const baseName = '{{baseName}}'
                for (const element of {{> requestPropertyName}}) {
                    await addFormParam(baseName, element, {{isBinary}}, {{isPrimitiveType}})
                }
            {{/isCollectionFormatMulti}}
            {{^isCollectionFormatMulti}}
            {{#items.isModel}}
            localVarFormParams.{{#multipartFormData}}append{{/multipartFormData}}{{^multipartFormData}}set{{/multipartFormData}}('{{baseName}}', JSON.stringify({{> requestPropertyName}}));
            {{/items.isModel}}
            {{^items.isModel}}
            localVarFormParams.{{#multipartFormData}}append{{/multipartFormData}}{{^multipartFormData}}set{{/multipartFormData}}('{{baseName}}', {{> requestPropertyName}}.join(COLLECTION_FORMATS.{{collectionFormat}}));
            {{/items.isModel}}
            {{/isCollectionFormatMulti}}
            }{{/isArray}}
            {{^isArray}}
            if ({{> requestPropertyName}} !== undefined) {
                await addFormParam('{{baseName}}', {{> requestPropertyName}}, {{isBinary}}, {{isPrimitiveType}})
            }{{/isArray}}
    {{/formParams}}{{/vendorExtensions}}
    {{#vendorExtensions}}{{#hasFormParams}}{{^multipartFormData}}
            localVarHeaderParameter['Content-Type'] = 'application/x-www-form-urlencoded';{{/multipartFormData}}
    {{/hasFormParams}}{{/vendorExtensions}}
    {{#bodyParam}}
            {{^consumes}}
            localVarHeaderParameter['Content-Type'] = 'application/json';
            {{/consumes}}
            {{#consumes.0}}
            localVarHeaderParameter['Content-Type'] = '{{{mediaType}}}';
            {{/consumes.0}}

            {{#../vendorExtensions.multipartFormData}}
            {{#isArray}}
            if ({{> requestPropertyName}}) {
                {{#itemsDereferenced}}
                for (const element of {{> requestPropertyName}}) {
                {{#vars}}
                    await addFormParam('{{baseName}}', element.{{baseName}}, {{isBinary}}, {{isPrimitiveType}})
                {{/vars}}
                {{^isModel}}
                    await addFormParam('{{name}}', element, {{isBinary}}, {{isPrimitiveType}})
                {{/isModel}}
                }
                {{/itemsDereferenced}}
            }
            {{/isArray}}
            {{/../vendorExtensions.multipartFormData}}

    {{/bodyParam}}
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions,{{#hasFormParams}}{{#multipartFormData}} ...(localVarFormParams as any).getHeaders?.(),{{/multipartFormData}}{{/hasFormParams}} ...options.headers};
    {{#vendorExtensions.multipartFormData}}
            localVarRequestOptions.data = localVarFormParams;
    {{/vendorExtensions.multipartFormData}}
    {{#bodyParam}}
            requestBeforeHook({
                requestBody: {{> requestPropertyName}},
                queryParameters: localVarQueryParameter,
                requestConfig: localVarRequestOptions,
                path: localVarPath,
                configuration,
                pathTemplate: '{{{path}}}',
                httpMethod: '{{httpMethod}}'
            });
    {{^../vendorExtensions.multipartFormData}}
            localVarRequestOptions.data = serializeDataIfNeeded({{> requestPropertyName}}, localVarRequestOptions, configuration)
    {{/../vendorExtensions.multipartFormData}}
    {{/bodyParam}}
    {{^bodyParam}}
            requestBeforeHook({
                queryParameters: localVarQueryParameter,
                requestConfig: localVarRequestOptions,
                path: localVarPath,
                configuration,
                pathTemplate: '{{{path}}}',
                httpMethod: '{{httpMethod}}'
            });
    {{/bodyParam}}

            setSearchParams(localVarUrlObj, localVarQueryParameter);
            return {
                url: toPathString(localVarUrlObj),
                options: localVarRequestOptions,
            };
        },
    {{/operation}}
    }
};

/**
 * {{classname}} - functional programming interface{{#description}}
 * {{{.}}}{{/description}}
 * @export
 */
export const {{classname}}Fp = function(configuration?: Configuration) {
    const localVarAxiosParamCreator = {{classname}}AxiosParamCreator(configuration)
    return {
    {{#operation}}
        /**
         * {{&notes}}
         {{#summary}}
         * @summary {{&summary}}
         {{/summary}}
        {{#useSingleRequestParameter}}
         {{#allParams.0}}
         * @param {{=<% %>=}}{<%& classname %><%& operationIdCamelCase %>Request}<%={{ }}=%> requestParameters Request parameters.
         {{/allParams.0}}
        {{/useSingleRequestParameter}}
        {{^useSingleRequestParameter}}
         {{#allParams}}
         * @param {{=<% %>=}}{<%&dataType%>}<%={{ }}=%> {{^required}}[{{/required}}{{> requestPropertyName}}{{^required}}]{{/required}} {{description}}
         {{/allParams}}
        {{/useSingleRequestParameter}}
         * @param {*} [options] Override http request option.{{#isDeprecated}}
         * @deprecated{{/isDeprecated}}
         * @throws {RequiredError}
         */
        {{#useSingleRequestParameter}}
        async {{nickname}}({{> apiInner_requestParameters}}options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{{{returnType}}}{{^returnType}}void{{/returnType}}>> {
            {{#bodyParam}}
            {{#isStrictlyObject}}
            const {{paramName}}: {{{dataType}}} = {
            {{#vars}}
                {{baseName}}: {{> requestBodyName}}.{{baseName}}{{^-last}},{{/-last}}
            {{/vars}}
            };
            {{/isStrictlyObject}}
            {{^isStrictlyObject}}
            const {{paramName}}: {{{dataType}}} = {{> requestBodyName}};
            {{/isStrictlyObject}}
            {{/bodyParam}}
            const localVarAxiosArgs = await localVarAxiosParamCreator.{{nickname}}({{#allParams}}{{#isBodyParam}}{{../bodyParam.paramName}}{{/isBodyParam}}{{^isBodyParam}}requestParameters.{{> requestPropertyName}}{{/isBodyParam}}, {{/allParams}}options);
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
        },
        {{/useSingleRequestParameter}}
        {{^useSingleRequestParameter}}
        async {{nickname}}({{#allParams}}{{> requestPropertyName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{{{returnType}}}{{^returnType}}void{{/returnType}}>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.{{nickname}}({{#allParams}}{{> requestPropertyName}}, {{/allParams}}options);
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
        },
        {{/useSingleRequestParameter}}
    {{/operation}}
    }
};

/**
 * {{classname}} - factory interface{{#description}}
 * {{&description}}{{/description}}
 * @export
 */
export const {{classname}}Factory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
    const localVarFp = {{classname}}Fp(configuration)
    return {
    {{#operation}}
        /**
         * {{&notes}}
         {{#summary}}
         * @summary {{&summary}}
         {{/summary}}
        {{#useSingleRequestParameter}}
         {{#allParams.0}}
         * @param {{=<% %>=}}{<%& classname %><%& operationIdCamelCase %>Request}<%={{ }}=%> requestParameters Request parameters.
         {{/allParams.0}}
        {{/useSingleRequestParameter}}
        {{^useSingleRequestParameter}}
         {{#allParams}}
         * @param {{=<% %>=}}{<%&dataType%>}<%={{ }}=%> {{^required}}[{{/required}}{{> requestPropertyName}}{{^required}}]{{/required}} {{description}}
         {{/allParams}}
        {{/useSingleRequestParameter}}
         * @param {*} [options] Override http request option.{{#isDeprecated}}
         * @deprecated{{/isDeprecated}}
         * @throws {RequiredError}
         */
        {{#useSingleRequestParameter}}
        {{nickname}}({{> apiInner_requestParameters}}options?: AxiosRequestConfig): AxiosPromise<{{{returnType}}}{{^returnType}}void{{/returnType}}> {
            return localVarFp.{{nickname}}({{#allParams.0}}requestParameters, {{/allParams.0}}options).then((request) => request(axios, basePath));
        },
        {{/useSingleRequestParameter}}
        {{^useSingleRequestParameter}}
        {{nickname}}({{#allParams}}{{> requestPropertyName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options?: any): AxiosPromise<{{{returnType}}}{{^returnType}}void{{/returnType}}> {
            return localVarFp.{{nickname}}({{#allParams}}{{> requestPropertyName}}, {{/allParams}}options).then((request) => request(axios, basePath));
        },
        {{/useSingleRequestParameter}}
    {{/operation}}
    };
};

{{#withInterfaces}}
/**
 * {{classname}} - interface{{#description}}
 * {{&description}}{{/description}}
 * @export
 * @interface {{classname}}
 */
export interface {{classname}}Interface {
{{#operation}}
    /**
     * {{&notes}}
     {{#summary}}
     * @summary {{&summary}}
     {{/summary}}
     {{#allParams}}
     * @param {{=<% %>=}}{<%&dataType%>}<%={{ }}=%> {{^required}}[{{/required}}{{> requestPropertyName}}{{^required}}]{{/required}} {{description}}
     {{/allParams}}
     * @param {*} [options] Override http request option.{{#isDeprecated}}
     * @deprecated{{/isDeprecated}}
     * @throws {RequiredError}
     * @memberof {{classname}}Interface
     */
    {{nickname}}({{#allParams}}{{> requestPropertyName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options?: AxiosRequestConfig): AxiosPromise<{{{returnType}}}{{^returnType}}void{{/returnType}}>;

{{/operation}}
}

{{/withInterfaces}}
{{#useSingleRequestParameter}}
{{#operation}}
{{#allParams.0}}
/**
 * Request parameters for {{nickname}} operation in {{classname}}.
 * @export
 * @interface {{> singleRequestParameterName}}
 */
export type {{> singleRequestParameterName}} = {{#onlyHasPrimitiveOrArrayBodyParameter}}{{{dataType}}}{{/onlyHasPrimitiveOrArrayBodyParameter}}{{^onlyHasPrimitiveOrArrayBodyParameter}}{{#hasParams}}{
 {{#operationVendorExtensions.x-konfig-operation-can-have-single-parameter}}
    {{#allParams}}{{^isBodyParam}}
    /**
    * {{{description}}}
    * @type {{=<% %>=}}{<%&dataType%>}<%={{ }}=%>
    * @memberof {{classname}}{{operationIdCamelCase}}
    */
    readonly {{> requestPropertyName}}{{^required}}?{{/required}}: {{{dataType}}}
    {{/isBodyParam}}{{/allParams}}
{{/operationVendorExtensions.x-konfig-operation-can-have-single-parameter}}
{{^operationVendorExtensions.x-konfig-operation-can-have-single-parameter}}
    {{#allParams}}
    /**
    * {{{description}}}
    * @type {{=<% %>=}}{<%&dataType%>}<%={{ }}=%>
    * @memberof {{classname}}{{operationIdCamelCase}}
    */
    readonly {{#isBodyParam}}requestBody{{/isBodyParam}}{{^isBodyParam}}{{> requestPropertyName}}{{/isBodyParam}}{{^required}}?{{/required}}: {{{dataType}}}
    {{/allParams}}
{{/operationVendorExtensions.x-konfig-operation-can-have-single-parameter}}
}{{/hasParams}}{{#bodyParam}}{{#operationVendorExtensions.x-konfig-operation-can-have-single-parameter}}{{^isArray}} & {{/isArray}}{{{dataType}}}{{/operationVendorExtensions.x-konfig-operation-can-have-single-parameter}}{{/bodyParam}}{{/onlyHasPrimitiveOrArrayBodyParameter}}

{{/allParams.0}}
{{/operation}}
{{/useSingleRequestParameter}}
/**
 * {{classname}}Generated - object-oriented interface{{#description}}
 * {{{.}}}{{/description}}
 * @export
 * @class {{classname}}Generated
 * @extends {BaseAPI}
 */
{{#withInterfaces}}
export class {{classname}}Generated extends BaseAPI implements {{classname}}Interface {
{{/withInterfaces}}
{{^withInterfaces}}
export class {{classname}}Generated extends BaseAPI {
{{/withInterfaces}}
    {{#operation}}
    /**
     * {{&notes}}
     {{#summary}}
     * @summary {{&summary}}
     {{/summary}}
     {{#useSingleRequestParameter}}
     {{#allParams.0}}
     * @param {{=<% %>=}}{<%& classname %><%& operationIdCamelCase %>Request}<%={{ }}=%> requestParameters Request parameters.
     {{/allParams.0}}
     {{/useSingleRequestParameter}}
     {{^useSingleRequestParameter}}
     {{#allParams}}
     * @param {{=<% %>=}}{<%&dataType%>}<%={{ }}=%> {{^required}}[{{/required}}{{> requestPropertyName}}{{^required}}]{{/required}} {{description}}
     {{/allParams}}
     {{/useSingleRequestParameter}}
     * @param {*} [options] Override http request option.{{#isDeprecated}}
     * @deprecated{{/isDeprecated}}
     * @throws {RequiredError}
     * @memberof {{classname}}Generated
     */
    {{#useSingleRequestParameter}}
    public {{nickname}}({{> apiInner_requestParameters}}options?: AxiosRequestConfig) {
        {{#vendorExtensions}}
        {{#x-konfig-pagination}}
        return paginate({
            initialParameters: requestParameters,
            request: (parameters: {{classname}}{{operationIdCamelCase}}Request) => {
                return {{classname}}Fp(this.configuration).{{nickname}}({{#allParams.0}}parameters, {{/allParams.0}}options).then((request) => request(this.axios, this.basePath));
            },
        });
        {{/x-konfig-pagination}}
        {{^x-konfig-pagination}}
        {{>apiSingleRequestParameterInvoke}}
        {{/x-konfig-pagination}}
        {{/vendorExtensions}}
        {{^vendorExtensions}}
        {{>apiSingleRequestParameterInvoke}}
        {{/vendorExtensions}}
    }
    {{/useSingleRequestParameter}}
    {{^useSingleRequestParameter}}
    public {{nickname}}({{#allParams}}{{> requestPropertyName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options?: AxiosRequestConfig) {
        return {{classname}}Fp(this.configuration).{{nickname}}({{#allParams}}{{> requestPropertyName}}, {{/allParams}}options).then((request) => request(this.axios, this.basePath));
    }
    {{/useSingleRequestParameter}}
    {{^-last}}

    {{/-last}}
    {{/operation}}
}
{{/operations}}
